import { defineStore } from 'pinia'
import request from '@/utils/request' // 改用拦截器实例
import { ElMessage, ElMessageBox } from 'element-plus'
import router from '@/router'

// 解析Token获取用户信息（对应后端JwtUtil的claims结构：存的是"id"而非"user_id"）
const getCurrentUser = () => {
  const token = localStorage.getItem('token')
  // 更严格的token检测：检查token是否存在且不为空字符串
  if (!token || token.trim() === '') return null
  
  try {
    // 解析JWT：后端JwtUtil将claims存在"claims"字段，需先取claims再拿id
    const tokenPayload = JSON.parse(atob(token.split('.')[1]))
    const claims = tokenPayload.claims // 对应后端JwtUtil.genToken的"claims"字段
    return {
      userId: claims.id, // 后端存的是"id"（User的userId）
      username: claims.username,
      token
    }
  } catch (e) {
    console.error('Token解析失败:', e)
    localStorage.removeItem('token') // 清除无效Token
    return null
  }
};

// 安全解析 coverList 字段
const parseCoverList = (coverList) => {
  // 如果已经是数组，直接返回
  if (Array.isArray(coverList)) {
    return coverList;
  }
  
  // 如果是字符串，尝试解析
  if (typeof coverList === 'string') {
    // 如果是空字符串，返回空数组
    if (!coverList.trim()) {
      return [];
    }
    
    // 如果看起来像URL（以http开头），包装成数组
    if (coverList.startsWith('http')) {
      return [coverList];
    }
    
    // 尝试解析JSON字符串
    try {
      const parsed = JSON.parse(coverList);
      return Array.isArray(parsed) ? parsed : [parsed];
    } catch (error) {
      console.warn('解析coverList失败:', coverList, error);
      return [];
    }
  }
  
  // 其他情况返回空数组
  return [];
};

export const useCartStore = defineStore('cart', {
  state: () => ({
    cartList: [], // 购物车商品列表
    loading: false, // 接口加载状态
    error: '' // 错误信息
  }),
  getters: {
    // 计算已选中商品数量
    selectedCount: (state) => {
      return state.cartList.reduce((total, item) => {
        return item.is_selected ? total + item.quantity : total
      }, 0)
    },
    // 计算已选中商品总价
    selectedTotalPrice: (state) => {
      return state.cartList.reduce((total, item) => {
        return item.is_selected ? total + (item.price * item.quantity) : total
      }, 0).toFixed(2)
    },
    // 判断是否全选
    isAllSelected: (state) => {
      const selectedItems = state.cartList.filter(item => item.is_selected)
      return state.cartList.length > 0 && selectedItems.length === state.cartList.length
    }
  },
  actions: {
    // 检查登录状态（内部调用，未登录则跳转）
    checkLogin() {
      const user = getCurrentUser()
      if (!user) {
        return null // 仅返回null，不直接跳转
      }
      return user
    },

    // 1. 获取购物车列表（无需传userId，后端从ThreadLocal拿）
    async fetchCartList() {
  const user = this.checkLogin()
  if (!user) return

  this.loading = true
  this.error = ''
  try {
    const res = await request.get('/cart/list')
    if (res.data && Array.isArray(res.data)) {
      this.cartList = res.data.map(item => ({
        ...item,
        price: item.price || 0, // 默认价格为 0
        quantity: item.quantity || 1, // 默认数量为 1
        coverList: parseCoverList(item.coverList) // 使用安全解析函数
      }))
    } else {
      this.cartList = []
      ElMessage.warning('购物车暂无商品')
    }
  } catch (err) {
    this.error = '获取购物车失败，请稍后重试'
    this.cartList = []
    console.error('获取购物车列表错误:', err)
  } finally {
    this.loading = false
  }
},

// 2. 添加商品到购物车（二手商品，数量固定为1）
async addCartItem(product, quantity = 1) {
    const user = this.checkLogin()
    if (!user) return
    
    // 检查商品是否已在购物车中
    if (this.isInCart(product.productId)) {
      ElMessage.warning('该商品已在购物车中')
      return
    }
    
    // 二手商品数量固定为1
    const fixedQuantity = 1
    
    this.loading = true
    this.error = ''
    try {
        const res = await request.post(
            '/cart/add',
            {},
            { params: { productId: product.productId, quantity: fixedQuantity } }
        )
        ElMessage.success(res.data) 
        await this.fetchCartList()
    } catch (err) {
        this.error = '添加购物车失败'
        ElMessage.error(this.error)
        console.error('添加购物车错误:', err)
    } finally {
        this.loading = false
    }
},

    // 3. 修改商品数量（二手商品禁止修改数量）
    async updateQuantity(cartId, newQuantity) {
      const user = this.checkLogin()
      if (!user) return
      
      // 二手商品数量固定为1，不允许修改
      ElMessage.warning('二手商品数量固定为1，无法修改')
      return
    },

    // 4. 删除购物车商品（单个删除）
    async deleteCartItem(cartId) {
      const user = this.checkLogin()
      if (!user) return

      ElMessageBox.confirm(
        '确定要删除该商品吗？',
        '确认删除',
        {
          confirmButtonText: '确定',
          cancelButtonText: '取消',
          type: 'warning'
        }
      ).then(async () => {
        this.loading = true
        try {
          await request.post('/cart/delete', { cart_id: cartId })
          ElMessage.success('商品已删除')
          await this.fetchCartList() // 刷新购物车
        } catch (err) {
          ElMessage.error('删除失败，请重试')
          console.error('删除商品错误:', err)
        } finally {
          this.loading = false
        }
      }).catch(() => {
        ElMessage.info('已取消删除')
      })
    },

    // 5. 切换商品选中状态
    async toggleSelect(cartId, isSelected) {
      const user = this.checkLogin()
      if (!user) return

      try {
        // 先局部更新（即时响应）
        const item = this.cartList.find(item => item.cart_id === cartId)
        if (item) item.is_selected = isSelected

        // 同步后端
        await request.post('/cart/toggleSelect', {
          cart_id: cartId,
          is_selected: isSelected ? 1 : 0
        })
      } catch (err) {
        if (item) item.is_selected = !isSelected // 接口失败回滚
        console.error('切换选中状态错误:', err)
        ElMessage.error('选中状态同步失败，请重试')
      }
    },

    // 6. 全选/取消全选（无需传userId）
    async selectAll(isAllSelected) {
      const user = this.checkLogin()
      if (!user) return

      const newStatus = !isAllSelected
      // 先局部更新
      this.cartList.forEach(item => item.is_selected = newStatus)

      try {
        // 后端从ThreadLocal拿userId
        await request.post('/cart/selectAll', {
          is_selected: newStatus ? 1 : 0
        })
        ElMessage.success(newStatus ? '已全选' : '已取消全选')
      } catch (err) {
        // 接口失败回滚
        this.cartList.forEach(item => item.is_selected = !newStatus)
        console.error('全选状态同步错误:', err)
        ElMessage.error('全选状态同步失败，请重试')
      }
    },

    // 7. 批量删除选中商品
    async batchDeleteSelected() {
      const user = this.checkLogin()
      if (!user) return

      const selectedItems = this.cartList.filter(item => item.is_selected)
      if (selectedItems.length === 0) {
        return ElMessage.warning('请先选中要删除的商品')
      }

      ElMessageBox.confirm(
        `确定要删除选中的${selectedItems.length}个商品吗？`,
        '批量删除确认',
        {
          confirmButtonText: '确定',
          cancelButtonText: '取消',
          type: 'warning'
        }
      ).then(async () => {
        this.loading = true
        try {
          const cartIds = selectedItems.map(item => item.cart_id)
          await request.post('/cart/batchDelete', cartIds) // 直接传id数组
          ElMessage.success(`已删除选中的${selectedItems.length}个商品`)
          await this.fetchCartList() // 刷新购物车
        } catch (err) {
          this.error = '批量删除失败，请重试'
          console.error('批量删除错误:', err)
          ElMessage.error(this.error)
        } finally {
          this.loading = false
        }
      }).catch(() => {
        ElMessage.info('已取消批量删除')
      })
    },

    // 检查商品是否已在购物车中
    isInCart(productId) {
      return this.cartList.some(item => item.productId === productId)
    },

    // 获取购物车中指定商品的信息
    getCartItem(productId) {
      return this.cartList.find(item => item.productId === productId)
    },
    
    // 清理已售商品的购物车数据
    async cleanSoldProductFromCart(productId) {
      try {
        console.log('CartStore: 开始清理已售商品的购物车数据:', productId)
        
        // 查找并移除已售商品
        const cartItem = this.getCartItem(productId)
        if (cartItem) {
          await this.removeCartItem(cartItem.id)
          console.log('CartStore: 已从购物车中移除已售商品:', productId)
        }
      } catch (error) {
        console.error('CartStore: 清理已售商品购物车数据失败:', error)
      }
    }
  }
})